home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 21 / AACD 21.iso / AACD / Programming / vahunz / source / ugly / expstr.c next >
Encoding:
C/C++ Source or Header  |  2001-04-17  |  6.7 KB  |  453 lines
  1. /*
  2.  * This source file is part of Vahunz,
  3.  * a tool to make source code un-/more legible.
  4.  *
  5.  *--------------------------------------------------------------------------
  6.  *
  7.  * Vahunz and the Ugly library are Copyright (C) 1998 by
  8.  * Thomas Aglassinger <agi@giga.or.at>
  9.  *
  10.  * All rights reserved.
  11.  *
  12.  * Refer to the manual for more information.
  13.  *
  14.  *--------------------------------------------------------------------------
  15.  *
  16.  * Ubiqx library is Copyright (C) 1991-1998 by
  17.  * Christopher R. Hertel <crh@ubiqx.mn.org>
  18.  *
  19.  * Ubiqx library is free software; you can redistribute it and/or
  20.  * modify it under the terms of the GNU Library General Public
  21.  * License as published by the Free Software Foundation; either
  22.  * version 2 of the License, or (at your option) any later version.
  23.  *
  24.  */
  25. #include <ctype.h>
  26. #include <stdlib.h>
  27. #include <stdio.h>
  28. #include <string.h>
  29. #include "utypes.h"
  30. #include "ustring.h"
  31. #include "umemory.h"
  32. #define c6D
  33. #include "expstr.h"
  34. #if j1Y
  35. #define D(x) x
  36. #define q3R "*expstr* "
  37. #else
  38. #define D(x) 
  39. #endif
  40. VOID n7U(VOID)
  41. {
  42. j5K *t0I = o8S(0); 
  43. j5K *o5J = o8S(0); 
  44. BOOL ok = ((BOOL) (t0I && o5J)); 
  45. if (ok)
  46. {
  47. ok &= a4D(t0I, "sepp"); 
  48. ok &= a4D(o5J, "hugo");
  49. ok &= u4W(t0I, ". "); 
  50. ok &= u4W(o5J, " and ");
  51. ok &= j0P(o5J, t0I); 
  52. ok &= h3A(t0I); 
  53. }
  54. if (ok)
  55. {
  56. if (strcmp(e4K(t0I), "hugo and sepp.") || i5C(t0I))
  57. {
  58. fprintf(stderr, "error in test_expstr: data mismatch\n");
  59. ok = FALSE;
  60. }
  61. }
  62. else
  63. {
  64. perror("error in test_expstr:");
  65. }
  66. y6Q(o5J); 
  67. y6Q(t0I);
  68. if (!ok)
  69. {
  70. abort();
  71. }
  72. }
  73. static void i8A(STRPTR t5W, STRPTR e9R, ULONG p8T)
  74. {
  75. fprintf(stderr, "\n##\n## panic: es=NULL in %s()\n##   called from %s (%lu)\n##\n",
  76. t5W, e9R, p8T);
  77. }
  78. static void s4Z(STRPTR t5W, STRPTR e9R, ULONG p8T)
  79. {
  80. fprintf(stderr, "\n##\n## panic: string=NULL in %s()\n##   called from %s (%lu)\n##\n",
  81. t5W, e9R, p8T);
  82. }
  83. static BOOL w7N(j5K * es, STRPTR k8A, size_t l6N)
  84. {
  85. BOOL ok = TRUE;
  86. if (k8A)
  87. {
  88. #if j1Y == 2
  89. D(fprintf(stderr, q3R "set to %lu (%p->%p)\n",
  90. l6N, es->r1C, k8A));
  91. #endif
  92. es->p3Q = l6N;
  93. es->r1C = k8A;
  94. }
  95. else
  96. ok = FALSE;
  97. return (ok);
  98. }
  99. BOOL f2B(j5K * es, size_t l6N)
  100. {
  101. return (w7N(es, (STRPTR) o4N(l6N), l6N));
  102. }
  103. BOOL h0Z(j5K * es, size_t l6N, STRPTR e9R, ULONG p8T)
  104. {
  105. BOOL ok = FALSE;
  106. if (!es)
  107. i8A("set_estr_mem", e9R, p8T);
  108. else
  109. {
  110. ok = w7N(es,
  111. (STRPTR) e3L(l6N, e9R, p8T),
  112. l6N);
  113. }
  114. return (ok);
  115. }
  116. BOOL f8T(j5K * es, t8B s)
  117. {
  118. BOOL ok = FALSE;
  119. size_t f3S = strlen(s) + 1;
  120. STRPTR j3P = es->r1C;
  121. if ((es->p3Q == es->x6G)
  122. && (es->p3Q > f3S))
  123. {
  124. strcpy(es->r1C, s); 
  125. es->r0H = f3S; 
  126. ok = TRUE;
  127. }
  128. else if (y8L(es, m4R(f3S, es->x6G)))
  129. {
  130. strcpy(es->r1C, s); 
  131. v3S(j3P);
  132. es->r0H = f3S; 
  133. ok = TRUE;
  134. }
  135. return (ok);
  136. }
  137. BOOL n4J(j5K * es, t8B s, STRPTR e9R, ULONG p8T)
  138. {
  139. BOOL ok = FALSE;
  140. if (!es)
  141. i8A("set_estr_mem", e9R, p8T);
  142. else if (!s)
  143. s4Z("set_estr_mem", e9R, p8T);
  144. else
  145. {
  146. size_t f3S = strlen(s) + 1;
  147. STRPTR j3P = es->r1C;
  148. #if j1Y == 2
  149. p4No("setestr()", e9R, p8T);
  150. #endif
  151. if ((es->p3Q == es->x6G)
  152. && (es->p3Q > f3S))
  153. {
  154. strcpy(es->r1C, s); 
  155. es->r0H = f3S; 
  156. ok = TRUE;
  157. }
  158. else if (h0Z(es, m4R(f3S, es->x6G), e9R, p8T))
  159. {
  160. strcpy(es->r1C, s); 
  161. x8C(j3P);
  162. es->r0H = f3S; 
  163. ok = TRUE;
  164. }
  165. #if j1Y == 2
  166. p4No("setestr()", e9R, p8T);
  167. #endif
  168. }
  169. return (ok);
  170. }
  171. BOOL k7N(j5K * es)
  172. {
  173. return (a4D(es, ""));
  174. }
  175. BOOL v2V(j5K * es, STRPTR e9R, ULONG p8T)
  176. {
  177. #if j1Y == 2
  178. STRPTR s = es->r1C;
  179. if (!s)
  180. s = "<null>";
  181. fprintf(stderr, q3R "clr_estr(%p,`%s')\n", es, s);
  182. p4No("clr_estr()", e9R, p8T);
  183. #endif
  184. return (n4J(es, "", e9R, p8T));
  185. }
  186. BOOL c9U(j5K * es, t8B s, size_t n)
  187. {
  188. BOOL ok = FALSE;
  189. STRPTR s1 = NULL;
  190. size_t b1B = strlen(s);
  191. if (n > b1B)
  192. n = b1B;
  193. s1 = (STRPTR) o4N(n + 1);
  194. if (s1)
  195. {
  196. memcpy(s1, s, n);
  197. s1[n] = 0;
  198. ok = a4D(es, s1);
  199. x8C(s1);
  200. }
  201. return (ok);
  202. }
  203. j5K *o0J(size_t g9W, STRPTR e9R, ULONG p8T)
  204. {
  205. j5K *es = (j5K *) e3L(sizeof(j5K), e9R, p8T);
  206. if (es)
  207. {
  208. if (g9W < h7L)
  209. g9W = h7L;
  210. es->r1C = NULL;
  211. es->p3Q = 0;
  212. es->x6G = g9W;
  213. if (!h3A(es))
  214. {
  215. x8C(es);
  216. es = NULL;
  217. }
  218. }
  219. return (es);
  220. }
  221. j5K *u5Y(size_t g9W)
  222. {
  223. j5K *es = (j5K *) o4N(sizeof(j5K));
  224. if (es)
  225. {
  226. if (g9W < h7L)
  227. g9W = h7L;
  228. es->r1C = NULL;
  229. es->p3Q = 0;
  230. es->x6G = g9W;
  231. if (!h3A(es))
  232. {
  233. x8C(es);
  234. es = NULL;
  235. }
  236. }
  237. return (es);
  238. }
  239. VOID y6Q(j5K * es)
  240. {
  241. #if j1Y
  242. if (es)
  243. {
  244. if (es->r1C)
  245. {
  246. #if j1Y == 2
  247. d6X s[17];
  248. strncpy(s, es->r1C, 17);
  249. s[16] = 0;
  250. D(fprintf(stderr, q3R "del_estr(%p,`%s')\n", es, s));
  251. d6O("del_estr()");
  252. #endif
  253. }
  254. else
  255. {
  256. D(fprintf(stderr, q3R "attempt to free null-data-estr\n"));
  257. }
  258. }
  259. else
  260. {
  261. #if j1Y == 2
  262. D(fprintf(stderr, q3R "attempt to free null-estr\n"));
  263. #endif
  264. }
  265. #endif
  266. if (es)
  267. {
  268. x8C(es->r1C);
  269. es->r0H = 0;
  270. es->p3Q = 0;
  271. es->x6G = 0;
  272. x8C(es);
  273. }
  274. }
  275. BOOL n4X(j5K * es, int ch)
  276. {
  277. BOOL ok = TRUE;
  278. if (es->r0H >= es->p3Q)
  279. { 
  280. STRPTR j3P = es->r1C; 
  281. if (y8L(es,
  282. es->p3Q + es->x6G))
  283. { 
  284. strcpy(es->r1C, 
  285. j3P);
  286. x8C(j3P); 
  287. }
  288. else
  289. {
  290. ok = FALSE;
  291. }
  292. }
  293. if (ok)
  294. {
  295. STRPTR s;
  296. s = es->r1C;
  297. s[es->r0H - 1] = ch; 
  298. s[es->r0H] = 0;
  299. es->r0H++; 
  300. }
  301. return (ok);
  302. }
  303. BOOL w9I(j5K * es, int ch, STRPTR e9R, ULONG p8T)
  304. {
  305. BOOL ok = TRUE;
  306. if (!es)
  307. {
  308. i8A("app_estrch", e9R, p8T);
  309. ok = FALSE;
  310. }
  311. else if (es->r0H >= es->p3Q)
  312. { 
  313. STRPTR j3P = es->r1C; 
  314. if (h0Z(es,
  315. es->p3Q + es->x6G, e9R, p8T))
  316. {
  317. strcpy(es->r1C, 
  318. j3P);
  319. x8C(j3P); 
  320. }
  321. else
  322. { 
  323. ok = FALSE;
  324. }
  325. }
  326. if (ok)
  327. {
  328. STRPTR s;
  329. s = es->r1C;
  330. s[es->r0H - 1] = ch; 
  331. s[es->r0H] = 0;
  332. es->r0H++; 
  333. }
  334. return (ok);
  335. }
  336. BOOL d1R(j5K * es, t8B s)
  337. {
  338. BOOL ok = TRUE;
  339. size_t x0E = strlen(s);
  340. ok = TRUE;
  341. if ((es->r0H + x0E - 1) >= es->p3Q)
  342. { 
  343. STRPTR j3P = es->r1C; 
  344. if (f2B(es,
  345. m4R(es->r0H + x0E + 1, es->x6G)))
  346. {
  347. strcpy(es->r1C, 
  348. j3P);
  349. x8C(j3P); 
  350. }
  351. else
  352. { 
  353. ok = FALSE;
  354. }
  355. }
  356. if (ok)
  357. {
  358. STRPTR ds;
  359. ds = es->r1C + (es->r0H - 1);
  360. strcat(ds, s);
  361. es->r0H += x0E; 
  362. es->r1C[es->r0H - 1] = 0;
  363. }
  364. return (ok);
  365. }
  366. BOOL n2K(j5K * es, t8B s, STRPTR e9R, ULONG p8T)
  367. {
  368. BOOL ok = FALSE;
  369. if (!es)
  370. i8A("app_estr", e9R, p8T);
  371. else if (!s)
  372. s4Z("app_estr", e9R, p8T);
  373. else
  374. {
  375. size_t x0E = strlen(s);
  376. ok = TRUE;
  377. if ((es->r0H + x0E - 1) >= es->p3Q)
  378. { 
  379. STRPTR j3P = es->r1C; 
  380. if (h0Z(es,
  381. m4R(es->r0H + x0E + 1, es->x6G), e9R, p8T))
  382. { 
  383. strcpy(es->r1C, 
  384. j3P);
  385. x8C(j3P); 
  386. }
  387. else
  388. { 
  389. ok = FALSE;
  390. }
  391. }
  392. if (ok)
  393. {
  394. STRPTR ds;
  395. ds = es->r1C + (es->r0H - 1);
  396. strcat(ds, s);
  397. es->r0H += x0E; 
  398. es->r1C[es->r0H - 1] = 0;
  399. }
  400. }
  401. return (ok);
  402. }
  403. BOOL w2K(j5K * dest, j5K * src, size_t k5L, size_t num)
  404. {
  405. BOOL ok = FALSE;
  406. j5K *e0Y = o8S(dest->x6G);
  407. if (e0Y)
  408. {
  409. STRPTR j3P = e0Y->r1C;
  410. if (k5L >= src->r0H)
  411. k5L = src->r0H - 1;
  412. if (k5L + num >= src->r0H)
  413. num = src->r0H - k5L - 1;
  414. ok = y8L(e0Y, m4R(num + 1, e0Y->x6G));
  415. if (ok)
  416. {
  417. strncpy(e4K(e0Y), e4K(src) + k5L, num);
  418. e0Y->r1C[num] = 0;
  419. e0Y->r0H = num + 1;
  420. x8C(j3P);
  421. ok = k6F(dest, e0Y);
  422. }
  423. y6Q(e0Y);
  424. }
  425. return (ok);
  426. }
  427. BOOL h3M(j5K * dest, j5K * src, size_t num)
  428. {
  429. if (num >= src->r0H)
  430. num = src->r0H - 1;
  431. return (w2K(dest, src, (src->r0H - num - 1), num));
  432. }
  433. BOOL i2T(j5K * dest, j5K * src, size_t num)
  434. {
  435. return (w2K(dest, src, 0, num));
  436. }
  437. STRPTR p1W(j5K * es)
  438. {
  439. return (es->r1C);
  440. }
  441. size_t y1C(j5K * es)
  442. {
  443. return (es->r0H - 1);
  444. }
  445. BOOL k6F(j5K * dest, j5K * src)
  446. {
  447. return (a4D(dest, e4K(src)));
  448. }
  449. BOOL j0P(j5K * dest, j5K * src)
  450. {
  451. return (u4W(dest, e4K(src)));
  452. }
  453.